1. Uncapped concurrency per batch — BATCH_SIZE = 50                                                                                         
With BATCH_SIZE = 50, every batch fires 50 simultaneous HTTP POST requests. OkHttp's default per-host connection limit is 5 concurrent connections. The remaining 45 will queue    
inside OkHttp and serialize anyway — giving no speedup — while consuming thread/memory resources and potentially starving other in-flight requests (sync, image loads). The server 
(a Planet Community instance, often a Raspberry Pi or low-end hardware) may also struggle under 50 simultaneous writes.                                                            
                                                                                                                                                                                   
Fix: Use a Semaphore or Flow.flatMapMerge(concurrency = N) to cap actual concurrency to something like 4–8, which aligns with OkHttp's real throughput.                            
   
  val semaphore = Semaphore(6)                                                                                                                                                       
  val deferreds = batch.map { activityData ->                                                                                                                                      
      async {                                                                                                                                                                        
          semaphore.withPermit {
              // postDoc call                                                                                                                                                        
          }                                                                                                                                                                        
      }
  }

2. withContext(dispatcherProvider.io) is redundant noise                                                                       
Retrofit suspend functions already dispatch off the main thread. Wrapping async blocks in withContext(io) doesn't hurt correctness but misleads the reader into thinking a thread  
switch is necessary. The async blocks inherit whatever dispatcher withContext sets, but Retrofit ignores it. Remove the withContext wrapper and keep only the async/awaitAll     
pattern.